home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / nss / sslimpl.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-04-20  |  49.5 KB  |  1,394 lines
  1. /*
  2.  * This file is PRIVATE to SSL and should be the first thing included by
  3.  * any SSL implementation file.
  4.  *
  5.  * ***** BEGIN LICENSE BLOCK *****
  6.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  7.  *
  8.  * The contents of this file are subject to the Mozilla Public License Version
  9.  * 1.1 (the "License"); you may not use this file except in compliance with
  10.  * the License. You may obtain a copy of the License at
  11.  * http://www.mozilla.org/MPL/
  12.  *
  13.  * Software distributed under the License is distributed on an "AS IS" basis,
  14.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  15.  * for the specific language governing rights and limitations under the
  16.  * License.
  17.  *
  18.  * The Original Code is the Netscape security libraries.
  19.  *
  20.  * The Initial Developer of the Original Code is
  21.  * Netscape Communications Corporation.
  22.  * Portions created by the Initial Developer are Copyright (C) 1994-2000
  23.  * the Initial Developer. All Rights Reserved.
  24.  *
  25.  * Contributor(s):
  26.  *   Dr Stephen Henson <stephen.henson@gemplus.com>
  27.  *   Dr Vipul Gupta <vipul.gupta@sun.com>, Sun Microsystems Laboratories
  28.  *
  29.  * Alternatively, the contents of this file may be used under the terms of
  30.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  31.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  32.  * in which case the provisions of the GPL or the LGPL are applicable instead
  33.  * of those above. If you wish to allow use of your version of this file only
  34.  * under the terms of either the GPL or the LGPL, and not to allow others to
  35.  * use your version of this file under the terms of the MPL, indicate your
  36.  * decision by deleting the provisions above and replace them with the notice
  37.  * and other provisions required by the GPL or the LGPL. If you do not delete
  38.  * the provisions above, a recipient may use your version of this file under
  39.  * the terms of any one of the MPL, the GPL or the LGPL.
  40.  *
  41.  * ***** END LICENSE BLOCK ***** */
  42. /* $Id: sslimpl.h,v 1.42 2005/09/16 21:28:20 julien.pierre.bugs%sun.com Exp $ */
  43.  
  44. #ifndef __sslimpl_h_
  45. #define __sslimpl_h_
  46.  
  47. #ifdef DEBUG
  48. #undef NDEBUG
  49. #else
  50. #undef NDEBUG
  51. #define NDEBUG
  52. #endif
  53. #include "secport.h"
  54. #include "secerr.h"
  55. #include "sslerr.h"
  56. #include "ssl3prot.h"
  57. #include "hasht.h"
  58. #include "nssilock.h"
  59. #include "pkcs11t.h"
  60. #if defined(XP_UNIX) || defined(XP_BEOS)
  61. #include "unistd.h"
  62. #endif
  63. #include "nssrwlk.h"
  64. #include "prthread.h"
  65.  
  66. #include "sslt.h" /* for some formerly private types, now public */
  67.  
  68. /* to make some of these old enums public without namespace pollution,
  69. ** it was necessary to prepend ssl_ to the names.
  70. ** These #defines preserve compatibility with the old code here in libssl.
  71. */
  72. typedef SSLKEAType      SSL3KEAType;
  73. typedef SSLMACAlgorithm SSL3MACAlgorithm;
  74. typedef SSLSignType     SSL3SignType;
  75.  
  76. #define sign_null    ssl_sign_null
  77. #define sign_rsa    ssl_sign_rsa
  78. #define sign_dsa    ssl_sign_dsa
  79. #define sign_ecdsa    ssl_sign_ecdsa
  80.  
  81. #define calg_null    ssl_calg_null
  82. #define calg_rc4    ssl_calg_rc4
  83. #define calg_rc2    ssl_calg_rc2
  84. #define calg_des    ssl_calg_des
  85. #define calg_3des    ssl_calg_3des
  86. #define calg_idea    ssl_calg_idea
  87. #define calg_fortezza    ssl_calg_fortezza /* deprecated, must preserve */
  88. #define calg_aes    ssl_calg_aes
  89.  
  90. #define mac_null    ssl_mac_null
  91. #define mac_md5     ssl_mac_md5
  92. #define mac_sha     ssl_mac_sha
  93. #define hmac_md5    ssl_hmac_md5
  94. #define hmac_sha    ssl_hmac_sha
  95.  
  96. #define SET_ERROR_CODE        /* reminder */
  97. #define SEND_ALERT        /* reminder */
  98. #define TEST_FOR_FAILURE    /* reminder */
  99. #define DEAL_WITH_FAILURE    /* reminder */
  100.  
  101. #if defined(DEBUG) || defined(TRACE)
  102. #ifdef __cplusplus
  103. #define Debug 1
  104. #else
  105. extern int Debug;
  106. #endif
  107. #else
  108. #undef Debug
  109. #endif
  110.  
  111. #if defined(DEBUG) && !defined(TRACE) && !defined(NISCC_TEST)
  112. #define TRACE
  113. #endif
  114.  
  115. #ifdef TRACE
  116. #define SSL_TRC(a,b) if (ssl_trace >= (a)) ssl_Trace b
  117. #define PRINT_BUF(a,b) if (ssl_trace >= (a)) ssl_PrintBuf b
  118. #define DUMP_MSG(a,b) if (ssl_trace >= (a)) ssl_DumpMsg b
  119. #else
  120. #define SSL_TRC(a,b)
  121. #define PRINT_BUF(a,b)
  122. #define DUMP_MSG(a,b)
  123. #endif
  124.  
  125. #ifdef DEBUG
  126. #define SSL_DBG(b) if (ssl_debug) ssl_Trace b
  127. #else
  128. #define SSL_DBG(b)
  129. #endif
  130.  
  131. #if defined (DEBUG)
  132. #ifdef macintosh
  133. #include "pprthred.h"
  134. #else
  135. #include "private/pprthred.h"    /* for PR_InMonitor() */
  136. #endif
  137. #define ssl_InMonitor(m) PZ_InMonitor(m)
  138. #endif
  139.  
  140. #define LSB(x) ((unsigned char) (x & 0xff))
  141. #define MSB(x) ((unsigned char) (((unsigned)(x)) >> 8))
  142.  
  143. /************************************************************************/
  144.  
  145. typedef enum { SSLAppOpRead = 0,
  146.            SSLAppOpWrite,
  147.            SSLAppOpRDWR,
  148.            SSLAppOpPost,
  149.            SSLAppOpHeader
  150. } SSLAppOperation;
  151.  
  152. #define SSL_MIN_MASTER_KEY_BYTES    5
  153. #define SSL_MAX_MASTER_KEY_BYTES    64
  154.  
  155. #define SSL2_SESSIONID_BYTES        16
  156. #define SSL3_SESSIONID_BYTES        32
  157.  
  158. #define SSL_MIN_CHALLENGE_BYTES        16
  159. #define SSL_MAX_CHALLENGE_BYTES        32
  160. #define SSL_CHALLENGE_BYTES        16
  161.  
  162. #define SSL_CONNECTIONID_BYTES        16
  163.  
  164. #define SSL_MIN_CYPHER_ARG_BYTES    0
  165. #define SSL_MAX_CYPHER_ARG_BYTES    32
  166.  
  167. #define SSL_MAX_MAC_BYTES        16
  168.  
  169. #define SSL3_RSA_PMS_LENGTH 48
  170. #define SSL3_MASTER_SECRET_LENGTH 48
  171.  
  172. /* number of wrap mechanisms potentially used to wrap master secrets. */
  173. #define SSL_NUM_WRAP_MECHS              13
  174.  
  175. /* This makes the cert cache entry exactly 4k. */
  176. #define SSL_MAX_CACHED_CERT_LEN        4060
  177.  
  178. #define NUM_MIXERS                      9
  179.  
  180. #ifndef BPB
  181. #define BPB 8 /* Bits Per Byte */
  182. #endif
  183.  
  184. typedef struct sslBufferStr             sslBuffer;
  185. typedef struct sslConnectInfoStr        sslConnectInfo;
  186. typedef struct sslGatherStr             sslGather;
  187. typedef struct sslSecurityInfoStr       sslSecurityInfo;
  188. typedef struct sslSessionIDStr          sslSessionID;
  189. typedef struct sslSocketStr             sslSocket;
  190. typedef struct sslSocketOpsStr          sslSocketOps;
  191.  
  192. typedef struct ssl3StateStr             ssl3State;
  193. typedef struct ssl3CertNodeStr          ssl3CertNode;
  194. typedef struct ssl3BulkCipherDefStr     ssl3BulkCipherDef;
  195. typedef struct ssl3MACDefStr            ssl3MACDef;
  196. typedef struct ssl3KeyPairStr        ssl3KeyPair;
  197.  
  198. struct ssl3CertNodeStr {
  199.     struct ssl3CertNodeStr *next;
  200.     CERTCertificate *       cert;
  201. };
  202.  
  203. typedef SECStatus (*sslHandshakeFunc)(sslSocket *ss);
  204.  
  205. /* This type points to the low layer send func, 
  206. ** e.g. ssl2_SendStream or ssl3_SendPlainText.
  207. ** These functions return the same values as PR_Send, 
  208. ** i.e.  >= 0 means number of bytes sent, < 0 means error.
  209. */
  210. typedef PRInt32       (*sslSendFunc)(sslSocket *ss, const unsigned char *buf,
  211.                          PRInt32 n, PRInt32 flags);
  212.  
  213. typedef void          (*sslSessionIDCacheFunc)  (sslSessionID *sid);
  214. typedef void          (*sslSessionIDUncacheFunc)(sslSessionID *sid);
  215. typedef sslSessionID *(*sslSessionIDLookupFunc)(const PRIPv6Addr    *addr,
  216.                         unsigned char* sid,
  217.                         unsigned int   sidLen,
  218.                                                 CERTCertDBHandle * dbHandle);
  219.  
  220.  
  221. /* Socket ops */
  222. struct sslSocketOpsStr {
  223.     int         (*connect) (sslSocket *, const PRNetAddr *);
  224.     PRFileDesc *(*accept)  (sslSocket *, PRNetAddr *);
  225.     int         (*bind)    (sslSocket *, const PRNetAddr *);
  226.     int         (*listen)  (sslSocket *, int);
  227.     int         (*shutdown)(sslSocket *, int);
  228.     int         (*close)   (sslSocket *);
  229.  
  230.     int         (*recv)    (sslSocket *, unsigned char *, int, int);
  231.  
  232.     /* points to the higher-layer send func, e.g. ssl_SecureSend. */
  233.     int         (*send)    (sslSocket *, const unsigned char *, int, int);
  234.     int         (*read)    (sslSocket *, unsigned char *, int);
  235.     int         (*write)   (sslSocket *, const unsigned char *, int);
  236.  
  237.     int         (*getpeername)(sslSocket *, PRNetAddr *);
  238.     int         (*getsockname)(sslSocket *, PRNetAddr *);
  239. };
  240.  
  241. /* Flags interpreted by ssl send functions. */
  242. #define ssl_SEND_FLAG_FORCE_INTO_BUFFER    0x40000000
  243. #define ssl_SEND_FLAG_NO_BUFFER        0x20000000
  244. #define ssl_SEND_FLAG_MASK        0x7f000000
  245.  
  246. /*
  247. ** A buffer object.
  248. */
  249. struct sslBufferStr {
  250.     unsigned char *    buf;
  251.     unsigned int     len;
  252.     unsigned int     space;
  253. };
  254.  
  255. /*
  256. ** SSL3 cipher suite policy and preference struct.
  257. */
  258. typedef struct {
  259. #if !defined(_WIN32)
  260.     unsigned int    cipher_suite : 16;
  261.     unsigned int    policy       :  8;
  262.     unsigned int    enabled      :  1;
  263.     unsigned int    isPresent    :  1;
  264. #else
  265.     ssl3CipherSuite cipher_suite;
  266.     PRUint8         policy;
  267.     unsigned char   enabled   : 1;
  268.     unsigned char   isPresent : 1;
  269. #endif
  270. } ssl3CipherSuiteCfg;
  271.  
  272. #ifdef NSS_ENABLE_ECC
  273. #define ssl_V3_SUITES_IMPLEMENTED 40
  274. #else
  275. #define ssl_V3_SUITES_IMPLEMENTED 26
  276. #endif /* NSS_ENABLE_ECC */
  277.  
  278. typedef struct sslOptionsStr {
  279.     unsigned int useSecurity        : 1;  /*  1 */
  280.     unsigned int useSocks        : 1;  /*  2 */
  281.     unsigned int requestCertificate    : 1;  /*  3 */
  282.     unsigned int requireCertificate    : 2;  /*  4-5 */
  283.     unsigned int handshakeAsClient    : 1;  /*  6 */
  284.     unsigned int handshakeAsServer    : 1;  /*  7 */
  285.     unsigned int enableSSL2        : 1;  /*  8 */
  286.     unsigned int enableSSL3        : 1;  /*  9 */
  287.     unsigned int enableTLS        : 1;  /* 10 */
  288.     unsigned int noCache        : 1;  /* 11 */
  289.     unsigned int fdx            : 1;  /* 12 */
  290.     unsigned int v2CompatibleHello    : 1;  /* 13 */
  291.     unsigned int detectRollBack      : 1;  /* 14 */
  292.     unsigned int noStepDown             : 1;  /* 15 */
  293.     unsigned int bypassPKCS11           : 1;  /* 16 */
  294.     unsigned int noLocks                : 1;  /* 17 */
  295. } sslOptions;
  296.  
  297. typedef enum { sslHandshakingUndetermined = 0,
  298.            sslHandshakingAsClient,
  299.            sslHandshakingAsServer 
  300. } sslHandshakingType;
  301.  
  302. typedef struct sslServerCertsStr {
  303.     /* Configuration state for server sockets */
  304.     CERTCertificate *     serverCert;
  305.     CERTCertificateList * serverCertChain;
  306.     ssl3KeyPair *         serverKeyPair;
  307.     unsigned int          serverKeyBits;
  308. } sslServerCerts;
  309.  
  310. #define SERVERKEY serverKeyPair->privKey
  311.  
  312. #define SSL_LOCK_RANK_SPEC     255
  313. #define SSL_LOCK_RANK_GLOBAL     NSS_RWLOCK_RANK_NONE
  314.  
  315. /* These are the valid values for shutdownHow. 
  316. ** These values are each 1 greater than the NSPR values, and the code
  317. ** depends on that relation to efficiently convert PR_SHUTDOWN values 
  318. ** into ssl_SHUTDOWN values.  These values use one bit for read, and 
  319. ** another bit for write, and can be used as bitmasks.
  320. */
  321. #define ssl_SHUTDOWN_NONE    0    /* NOT shutdown at all */
  322. #define ssl_SHUTDOWN_RCV    1    /* PR_SHUTDOWN_RCV  +1 */
  323. #define ssl_SHUTDOWN_SEND    2    /* PR_SHUTDOWN_SEND +1 */
  324. #define ssl_SHUTDOWN_BOTH    3    /* PR_SHUTDOWN_BOTH +1 */
  325.  
  326. /*
  327. ** A gather object. Used to read some data until a count has been
  328. ** satisfied. Primarily for support of async sockets.
  329. ** Everything in here is protected by the recvBufLock.
  330. */
  331. struct sslGatherStr {
  332.     int           state;    /* see GS_ values below. */     /* ssl 2 & 3 */
  333.  
  334.     /* "buf" holds received plaintext SSL records, after decrypt and MAC check.
  335.      * SSL2: recv'd ciphertext records are put here, then decrypted in place.
  336.      * SSL3: recv'd ciphertext records are put in inbuf (see below), then 
  337.      *       decrypted into buf.
  338.      */
  339.     sslBuffer     buf;                /*recvBufLock*/    /* ssl 2 & 3 */
  340.  
  341.     /* number of bytes previously read into hdr or buf(ssl2) or inbuf (ssl3). 
  342.     ** (offset - writeOffset) is the number of ciphertext bytes read in but 
  343.     **     not yet deciphered.
  344.     */
  345.     unsigned int  offset;                                       /* ssl 2 & 3 */
  346.  
  347.     /* number of bytes to read in next call to ssl_DefRecv (recv) */
  348.     unsigned int  remainder;                                    /* ssl 2 & 3 */
  349.  
  350.     /* Number of ciphertext bytes to read in after 2-byte SSL record header. */
  351.     unsigned int  count;                    /* ssl2 only */
  352.  
  353.     /* size of the final plaintext record. 
  354.     ** == count - (recordPadding + MAC size)
  355.     */
  356.     unsigned int  recordLen;                    /* ssl2 only */
  357.  
  358.     /* number of bytes of padding to be removed after decrypting. */
  359.     /* This value is taken from the record's hdr[2], which means a too large
  360.      * value could crash us.
  361.      */
  362.     unsigned int  recordPadding;                /* ssl2 only */
  363.  
  364.     /* plaintext DATA begins this many bytes into "buf".  */
  365.     unsigned int  recordOffset;                    /* ssl2 only */
  366.  
  367.     int           encrypted;    /* SSL2 session is now encrypted.  ssl2 only */
  368.  
  369.     /* These next two values are used by SSL2 and SSL3.  
  370.     ** DoRecv uses them to extract application data.
  371.     ** The difference between writeOffset and readOffset is the amount of 
  372.     ** data available to the application.   Note that the actual offset of 
  373.     ** the data in "buf" is recordOffset (above), not readOffset.
  374.     ** In the current implementation, this is made available before the 
  375.     ** MAC is checked!!
  376.     */
  377.     unsigned int  readOffset;  /* Spot where DATA reader (e.g. application
  378.                                ** or handshake code) will read next.
  379.                                ** Always zero for SSl3 application data.
  380.                    */
  381.     /* offset in buf/inbuf/hdr into which new data will be read from socket. */
  382.     unsigned int  writeOffset; 
  383.  
  384.     /* Buffer for ssl3 to read (encrypted) data from the socket */
  385.     sslBuffer     inbuf;            /*recvBufLock*/    /* ssl3 only */
  386.  
  387.     /* The ssl[23]_GatherData functions read data into this buffer, rather
  388.     ** than into buf or inbuf, while in the GS_HEADER state.  
  389.     ** The portion of the SSL record header put here always comes off the wire 
  390.     ** as plaintext, never ciphertext.
  391.     ** For SSL2, the plaintext portion is two bytes long.  For SSl3 it is 5.
  392.     */
  393.     unsigned char hdr[5];                    /* ssl 2 & 3 */
  394. };
  395.  
  396. /* sslGather.state */
  397. #define GS_INIT        0
  398. #define GS_HEADER    1
  399. #define GS_MAC        2
  400. #define GS_DATA        3
  401. #define GS_PAD        4
  402.  
  403. typedef SECStatus (*SSLCipher)(void *               context, 
  404.                                unsigned char *      out,
  405.                    int *                outlen, 
  406.                    int                  maxout, 
  407.                    const unsigned char *in,
  408.                    int                  inlen);
  409. typedef SECStatus (*SSLDestroy)(void *context, PRBool freeit);
  410.  
  411.  
  412.  
  413. /*
  414. ** ssl3State and CipherSpec structs
  415. */
  416.  
  417. /* The SSL bulk cipher definition */
  418. typedef enum {
  419.     cipher_null,
  420.     cipher_rc4, 
  421.     cipher_rc4_40,
  422.     cipher_rc4_56,
  423.     cipher_rc2, 
  424.     cipher_rc2_40,
  425.     cipher_des, 
  426.     cipher_3des, 
  427.     cipher_des40,
  428.     cipher_idea, 
  429.     cipher_aes_128,
  430.     cipher_aes_256,
  431.     cipher_missing              /* reserved for no such supported cipher */
  432.     /* This enum must match ssl3_cipherName[] in ssl3con.c.  */
  433. } SSL3BulkCipher;
  434.  
  435. typedef enum { type_stream, type_block } CipherType;
  436.  
  437. #define MAX_IV_LENGTH 64
  438.  
  439. /*
  440.  * Do not depend upon 64 bit arithmetic in the underlying machine. 
  441.  */
  442. typedef struct {
  443.     uint32         high;
  444.     uint32         low;
  445. } SSL3SequenceNumber;
  446.  
  447. #define MAX_MAC_CONTEXT_BYTES 400
  448. #define MAX_MAC_CONTEXT_LLONGS (MAX_MAC_CONTEXT_BYTES / 8)
  449.  
  450. #define MAX_CIPHER_CONTEXT_BYTES 2080
  451. #define MAX_CIPHER_CONTEXT_LLONGS (MAX_CIPHER_CONTEXT_BYTES / 8)
  452.  
  453. typedef struct {
  454.     SSL3Opaque        client_write_iv         [24];
  455.     SSL3Opaque        server_write_iv         [24];
  456.     SSL3Opaque        wrapped_master_secret   [48];
  457.     PRUint16          wrapped_master_secret_len;
  458.     PRUint8           msIsWrapped;
  459.     PRUint8           resumable;
  460. } ssl3SidKeys; /* 100 bytes */
  461.  
  462. typedef struct {
  463.     PK11SymKey  *write_key;
  464.     PK11SymKey  *write_mac_key;
  465.     PK11Context *write_mac_context;
  466.     SECItem     write_key_item;
  467.     SECItem     write_iv_item;
  468.     SECItem     write_mac_key_item;
  469.     SSL3Opaque  write_iv[MAX_IV_LENGTH];
  470.     PRUint64    cipher_context[MAX_CIPHER_CONTEXT_LLONGS];
  471. } ssl3KeyMaterial;
  472.  
  473. /*
  474. ** These are the "specs" in the "ssl3" struct.
  475. ** Access to the pointers to these specs, and all the specs' contents
  476. ** (direct and indirect) is protected by the reader/writer lock ss->specLock.
  477. */
  478. typedef struct {
  479.     const ssl3BulkCipherDef *cipher_def;
  480.     const ssl3MACDef * mac_def;
  481.     int                mac_size;
  482.     SSLCipher          encode;
  483.     SSLCipher          decode;
  484.     SSLDestroy         destroy;
  485.     void *             encodeContext;
  486.     void *             decodeContext;
  487.     PRBool             bypassCiphers;    /* did double bypass (at least) */
  488.     PK11SymKey *       master_secret;
  489.     SSL3SequenceNumber write_seq_num;
  490.     SSL3SequenceNumber read_seq_num;
  491.     SSL3ProtocolVersion version;
  492.     ssl3KeyMaterial    client;
  493.     ssl3KeyMaterial    server;
  494.     SECItem            msItem;
  495.     unsigned char      key_block[NUM_MIXERS * MD5_LENGTH];
  496.     unsigned char      raw_master_secret[56];
  497. } ssl3CipherSpec;
  498.  
  499. typedef enum {    never_cached, 
  500.         in_client_cache, 
  501.         in_server_cache, 
  502.         invalid_cache        /* no longer in any cache. */
  503. } Cached;
  504.  
  505. struct sslSessionIDStr {
  506.     sslSessionID *        next;   /* chain used for client sockets, only */
  507.  
  508.     CERTCertificate *     peerCert;
  509.     const char *          peerID;     /* client only */
  510.     const char *          urlSvrName; /* client only */
  511.     CERTCertificate *     localCert;
  512.  
  513.     PRIPv6Addr            addr;
  514.     PRUint16              port;
  515.  
  516.     SSL3ProtocolVersion   version;
  517.  
  518.     PRUint32              creationTime;        /* seconds since Jan 1, 1970 */
  519.     PRUint32              lastAccessTime;    /* seconds since Jan 1, 1970 */
  520.     PRUint32              expirationTime;    /* seconds since Jan 1, 1970 */
  521.     Cached                cached;
  522.     int                   references;
  523.  
  524.     SSLSignType           authAlgorithm;
  525.     PRUint32              authKeyBits;
  526.     SSLKEAType            keaType;
  527.     PRUint32              keaKeyBits;
  528.  
  529.     union {
  530.     struct {
  531.         /* the V2 code depends upon the size of sessionID.  */
  532.         unsigned char         sessionID[SSL2_SESSIONID_BYTES];
  533.  
  534.         /* Stuff used to recreate key and read/write cipher objects */
  535.         SECItem               masterKey;        /* never wrapped */
  536.         int                   cipherType;
  537.         SECItem               cipherArg;
  538.         int                   keyBits;
  539.         int                   secretKeyBits;
  540.     } ssl2;
  541.     struct {
  542.         /* values that are copied into the server's on-disk SID cache. */
  543.         uint8                 sessionIDLength;
  544.         SSL3Opaque            sessionID[SSL3_SESSIONID_BYTES];
  545.  
  546.         ssl3CipherSuite       cipherSuite;
  547.         SSL3CompressionMethod compression;
  548.         int                   policy;
  549.         ssl3SidKeys           keys;
  550.         CK_MECHANISM_TYPE     masterWrapMech;
  551.                   /* mechanism used to wrap master secret */
  552.             SSL3KEAType           exchKeyType;
  553.                   /* key type used in exchange algorithm,
  554.                    * and to wrap the sym wrapping key. */
  555.  
  556.         /* The following values are NOT restored from the server's on-disk
  557.          * session cache, but are restored from the client's cache.
  558.          */
  559.          PK11SymKey *      clientWriteKey;
  560.         PK11SymKey *      serverWriteKey;
  561.  
  562.         /* The following values pertain to the slot that wrapped the 
  563.         ** master secret. (used only in client)
  564.         */
  565.         SECMODModuleID    masterModuleID;
  566.                     /* what module wrapped the master secret */
  567.         CK_SLOT_ID        masterSlotID;
  568.         PRUint16          masterWrapIndex;
  569.                 /* what's the key index for the wrapping key */
  570.         PRUint16          masterWrapSeries;
  571.                             /* keep track of the slot series, so we don't 
  572.                  * accidently try to use new keys after the 
  573.                  * card gets removed and replaced.*/
  574.  
  575.         /* The following values pertain to the slot that did the signature
  576.         ** for client auth.   (used only in client)
  577.         */
  578.         SECMODModuleID    clAuthModuleID;
  579.         CK_SLOT_ID        clAuthSlotID;
  580.         PRUint16          clAuthSeries;
  581.  
  582.             char              masterValid;
  583.         char              clAuthValid;
  584.  
  585.     } ssl3;
  586.     } u;
  587. };
  588.  
  589.  
  590. typedef struct ssl3CipherSuiteDefStr {
  591.     ssl3CipherSuite          cipher_suite;
  592.     SSL3BulkCipher           bulk_cipher_alg;
  593.     SSL3MACAlgorithm         mac_alg;
  594.     SSL3KeyExchangeAlgorithm key_exchange_alg;
  595. } ssl3CipherSuiteDef;
  596.  
  597. /*
  598. ** There are tables of these, all const.
  599. */
  600. typedef struct {
  601.     SSL3KeyExchangeAlgorithm kea;
  602.     SSL3KEAType              exchKeyType;
  603.     SSL3SignType             signKeyType;
  604.     PRBool                   is_limited;
  605.     int                      key_size_limit;
  606.     PRBool                   tls_keygen;
  607. } ssl3KEADef;
  608.  
  609. typedef enum { kg_null, kg_strong, kg_export } SSL3KeyGenMode;
  610.  
  611. /*
  612. ** There are tables of these, all const.
  613. */
  614. struct ssl3BulkCipherDefStr {
  615.     SSL3BulkCipher  cipher;
  616.     SSLCipherAlgorithm calg;
  617.     int             key_size;
  618.     int             secret_key_size;
  619.     CipherType      type;
  620.     int             iv_size;
  621.     int             block_size;
  622.     SSL3KeyGenMode  keygen_mode;
  623. };
  624.  
  625. /*
  626. ** There are tables of these, all const.
  627. */
  628. struct ssl3MACDefStr {
  629.     SSL3MACAlgorithm mac;
  630.     CK_MECHANISM_TYPE mmech;
  631.     int              pad_size;
  632.     int              mac_size;
  633. };
  634.  
  635. typedef enum {
  636.     wait_client_hello, 
  637.     wait_client_cert, 
  638.     wait_client_key,
  639.     wait_cert_verify, 
  640.     wait_change_cipher, 
  641.     wait_finished,
  642.     wait_server_hello, 
  643.     wait_server_cert, 
  644.     wait_server_key,
  645.     wait_cert_request, 
  646.     wait_hello_done,
  647.     idle_handshake
  648. } SSL3WaitState;
  649.  
  650. /*
  651. ** This is the "hs" member of the "ssl3" struct.
  652. ** This entire struct is protected by ssl3HandshakeLock
  653. */
  654. typedef struct SSL3HandshakeStateStr {
  655.     SSL3Random            server_random;
  656.     SSL3Random            client_random;
  657.     SSL3WaitState         ws;
  658.     PRUint64              md5_cx[MAX_MAC_CONTEXT_LLONGS];
  659.     PRUint64              sha_cx[MAX_MAC_CONTEXT_LLONGS];
  660.     PK11Context *         md5;            /* handshake running hashes */
  661.     PK11Context *         sha;
  662. const ssl3KEADef *        kea_def;
  663.     ssl3CipherSuite       cipher_suite;
  664. const ssl3CipherSuiteDef *suite_def;
  665.     SSL3CompressionMethod compression;
  666.     sslBuffer             msg_body;    /* protected by recvBufLock */
  667.                                /* partial handshake message from record layer */
  668.     unsigned int          header_bytes; 
  669.                                /* number of bytes consumed from handshake */
  670.                                /* message for message type and header length */
  671.     SSL3HandshakeType     msg_type;
  672.     unsigned long         msg_len;
  673.     SECItem               ca_list;     /* used only by client */
  674.     PRBool                isResuming;  /* are we resuming a session */
  675.     PRBool                rehandshake; /* immediately start another handshake 
  676.                                         * when this one finishes */
  677.     PRBool                usedStepDownKey;  /* we did a server key exchange. */
  678.     sslBuffer             msgState;    /* current state for handshake messages*/
  679.                                        /* protected by recvBufLock */
  680. } SSL3HandshakeState;
  681.  
  682.  
  683.  
  684. /*
  685. ** This is the "ssl3" struct, as in "ss->ssl3".
  686. ** note:
  687. ** usually,   crSpec == cwSpec and prSpec == pwSpec.  
  688. ** Sometimes, crSpec == pwSpec and prSpec == cwSpec.
  689. ** But there are never more than 2 actual specs.  
  690. ** No spec must ever be modified if either "current" pointer points to it.
  691. */
  692. struct ssl3StateStr {
  693.  
  694.     /*
  695.     ** The following Specs and Spec pointers must be protected using the 
  696.     ** Spec Lock.
  697.     */
  698.     ssl3CipherSpec *     crSpec;     /* current read spec. */
  699.     ssl3CipherSpec *     prSpec;     /* pending read spec. */
  700.     ssl3CipherSpec *     cwSpec;     /* current write spec. */
  701.     ssl3CipherSpec *     pwSpec;     /* pending write spec. */
  702.  
  703.     CERTCertificate *    clientCertificate;  /* used by client */
  704.     SECKEYPrivateKey *   clientPrivateKey;   /* used by client */
  705.     CERTCertificateList *clientCertChain;    /* used by client */
  706.     PRBool               sendEmptyCert;      /* used by client */
  707.  
  708.     int                  policy;
  709.             /* This says what cipher suites we can do, and should 
  710.              * be either SSL_ALLOWED or SSL_RESTRICTED 
  711.              */
  712.     PRArenaPool *        peerCertArena;  
  713.                 /* These are used to keep track of the peer CA */
  714.     void *               peerCertChain;     
  715.                 /* chain while we are trying to validate it.   */
  716.     CERTDistNames *      ca_list; 
  717.                 /* used by server.  trusted CAs for this socket. */
  718.     PRBool               initialized;
  719.     SSL3HandshakeState   hs;
  720.     ssl3CipherSpec       specs[2];    /* one is current, one is pending. */
  721. };
  722.  
  723. typedef struct {
  724.     SSL3ContentType      type;
  725.     SSL3ProtocolVersion  version;
  726.     sslBuffer *          buf;
  727. } SSL3Ciphertext;
  728.  
  729. struct ssl3KeyPairStr {
  730.     SECKEYPrivateKey *    privKey;        /* RSA step down key */
  731.     SECKEYPublicKey *     pubKey;        /* RSA step down key */
  732.     PRInt32               refCount;    /* use PR_Atomic calls for this. */
  733. };
  734.  
  735. typedef struct SSLWrappedSymWrappingKeyStr {
  736.     SSL3Opaque        wrappedSymmetricWrappingkey[512];
  737.     SSL3Opaque        wrapIV[24];
  738.     CK_MECHANISM_TYPE symWrapMechanism;  
  739.             /* unwrapped symmetric wrapping key uses this mechanism */
  740.     CK_MECHANISM_TYPE asymWrapMechanism; 
  741.             /* mechanism used to wrap the SymmetricWrappingKey using
  742.              * server's public and/or private keys. */
  743.     SSL3KEAType       exchKeyType;   /* type of keys used to wrap SymWrapKey*/
  744.     PRInt32           symWrapMechIndex;
  745.     PRUint16          wrappedSymKeyLen;
  746.     PRUint16          wrapIVLen;
  747. } SSLWrappedSymWrappingKey;
  748.  
  749.  
  750.  
  751.  
  752.  
  753.  
  754.  
  755.  
  756.  
  757.  
  758. /*
  759.  * SSL2 buffers used in SSL3.
  760.  *     writeBuf in the SecurityInfo maintained by sslsecur.c is used
  761.  *              to hold the data just about to be passed to the kernel
  762.  *     sendBuf in the ConnectInfo maintained by sslcon.c is used
  763.  *              to hold handshake messages as they are accumulated
  764.  */
  765.  
  766. /*
  767. ** This is "ci", as in "ss->sec.ci".
  768. **
  769. ** Protection:  All the variables in here are protected by 
  770. ** firstHandshakeLock AND (in ssl3) ssl3HandshakeLock 
  771. */
  772. struct sslConnectInfoStr {
  773.     /* outgoing handshakes appended to this. */
  774.     sslBuffer       sendBuf;                    /*xmitBufLock*/ /* ssl 2 & 3 */
  775.  
  776.     PRIPv6Addr      peer;                                       /* ssl 2 & 3 */
  777.     unsigned short  port;                                       /* ssl 2 & 3 */
  778.  
  779.     sslSessionID   *sid;                                        /* ssl 2 & 3 */
  780.  
  781.     /* see CIS_HAVE defines below for the bit values in *elements. */
  782.     char            elements;                    /* ssl2 only */
  783.     char            requiredElements;                /* ssl2 only */
  784.     char            sentElements;                               /* ssl2 only */
  785.  
  786.     char            sentFinished;                               /* ssl2 only */
  787.  
  788.     /* Length of server challenge.  Used by client when saving challenge */
  789.     int             serverChallengeLen;                         /* ssl2 only */
  790.     /* type of authentication requested by server */
  791.     unsigned char   authType;                                   /* ssl2 only */
  792.  
  793.     /* Challenge sent by client to server in client-hello message */
  794.     /* SSL3 gets a copy of this.  See ssl3_StartHandshakeHash().  */
  795.     unsigned char   clientChallenge[SSL_MAX_CHALLENGE_BYTES];   /* ssl 2 & 3 */
  796.  
  797.     /* Connection-id sent by server to client in server-hello message */
  798.     unsigned char   connectionID[SSL_CONNECTIONID_BYTES];    /* ssl2 only */
  799.  
  800.     /* Challenge sent by server to client in request-certificate message */
  801.     unsigned char   serverChallenge[SSL_MAX_CHALLENGE_BYTES];    /* ssl2 only */
  802.  
  803.     /* Information kept to handle a request-certificate message */
  804.     unsigned char   readKey[SSL_MAX_MASTER_KEY_BYTES];        /* ssl2 only */
  805.     unsigned char   writeKey[SSL_MAX_MASTER_KEY_BYTES];        /* ssl2 only */
  806.     unsigned        keySize;                    /* ssl2 only */
  807. };
  808.  
  809. /* bit values for ci->elements, ci->requiredElements, sentElements. */
  810. #define CIS_HAVE_MASTER_KEY        0x01
  811. #define CIS_HAVE_CERTIFICATE        0x02
  812. #define CIS_HAVE_FINISHED        0x04
  813. #define CIS_HAVE_VERIFY            0x08
  814.  
  815. /* Note: The entire content of this struct and whatever it points to gets
  816.  * blown away by SSL_ResetHandshake().  This is "sec" as in "ss->sec".
  817.  *
  818.  * Unless otherwise specified below, the contents of this struct are 
  819.  * protected by firstHandshakeLock AND (in ssl3) ssl3HandshakeLock.
  820.  */
  821. struct sslSecurityInfoStr {
  822.     sslSendFunc      send;            /*xmitBufLock*/    /* ssl 2 & 3 */
  823.     int              isServer;            /* Spec Lock?*/    /* ssl 2 & 3 */
  824.     sslBuffer        writeBuf;            /*xmitBufLock*/    /* ssl 2 & 3 */
  825.  
  826.     int              cipherType;                /* ssl 2 & 3 */
  827.     int              keyBits;                    /* ssl 2 & 3 */
  828.     int              secretKeyBits;                /* ssl 2 & 3 */
  829.     CERTCertificate *localCert;                    /* ssl 2 & 3 */
  830.     CERTCertificate *peerCert;                    /* ssl 2 & 3 */
  831.     SECKEYPublicKey *peerKey;                    /* ssl3 only */
  832.  
  833.     SSLSignType      authAlgorithm;
  834.     PRUint32         authKeyBits;
  835.     SSLKEAType       keaType;
  836.     PRUint32         keaKeyBits;
  837.  
  838.     /*
  839.     ** Procs used for SID cache (nonce) management. 
  840.     ** Different implementations exist for clients/servers 
  841.     ** The lookup proc is only used for servers.  Baloney!
  842.     */
  843.     sslSessionIDCacheFunc     cache;                /* ssl 2 & 3 */
  844.     sslSessionIDUncacheFunc   uncache;                /* ssl 2 & 3 */
  845.  
  846.     /*
  847.     ** everything below here is for ssl2 only.
  848.     ** This stuff is equivalent to SSL3's "spec", and is protected by the 
  849.     ** same "Spec Lock" as used for SSL3's specs.
  850.     */
  851.     uint32           sendSequence;        /*xmitBufLock*/    /* ssl2 only */
  852.     uint32           rcvSequence;        /*recvBufLock*/    /* ssl2 only */
  853.  
  854.     /* Hash information; used for one-way-hash functions (MD2, MD5, etc.) */
  855.     const SECHashObject   *hash;        /* Spec Lock */ /* ssl2 only */
  856.     void            *hashcx;            /* Spec Lock */    /* ssl2 only */
  857.  
  858.     SECItem          sendSecret;        /* Spec Lock */    /* ssl2 only */
  859.     SECItem          rcvSecret;            /* Spec Lock */    /* ssl2 only */
  860.  
  861.     /* Session cypher contexts; one for each direction */
  862.     void            *readcx;            /* Spec Lock */    /* ssl2 only */
  863.     void            *writecx;            /* Spec Lock */    /* ssl2 only */
  864.     SSLCipher        enc;            /* Spec Lock */    /* ssl2 only */
  865.     SSLCipher        dec;            /* Spec Lock */    /* ssl2 only */
  866.     void           (*destroy)(void *, PRBool);    /* Spec Lock */    /* ssl2 only */
  867.  
  868.     /* Blocking information for the session cypher */
  869.     int              blockShift;        /* Spec Lock */    /* ssl2 only */
  870.     int              blockSize;            /* Spec Lock */    /* ssl2 only */
  871.  
  872.     /* These are used during a connection handshake */
  873.     sslConnectInfo   ci;                    /* ssl 2 & 3 */
  874.  
  875. };
  876.  
  877.  
  878. /*
  879. ** SSL Socket struct
  880. **
  881. ** Protection:  XXX
  882. */
  883. struct sslSocketStr {
  884.     PRFileDesc *    fd;
  885.  
  886.     /* Pointer to operations vector for this socket */
  887.     const sslSocketOps * ops;
  888.  
  889.     /* SSL socket options */
  890.     sslOptions       opt;
  891.  
  892.     /* State flags */
  893.     unsigned long    clientAuthRequested;
  894.     unsigned long    delayDisabled;       /* Nagle delay disabled */
  895.     unsigned long    firstHsDone;         /* first handshake is complete. */
  896.     unsigned long    handshakeBegun;     
  897.     unsigned long    lastWriteBlocked;   
  898.     unsigned long    recvdCloseNotify;    /* received SSL EOF. */
  899.     unsigned long    TCPconnected;       
  900.  
  901.     /* version of the protocol to use */
  902.     SSL3ProtocolVersion version;
  903.     SSL3ProtocolVersion clientHelloVersion; /* version sent in client hello. */
  904.  
  905.     sslSecurityInfo  sec;        /* not a pointer any more */
  906.  
  907.     /* protected by firstHandshakeLock AND (in ssl3) ssl3HandshakeLock. */
  908.     const char      *url;                /* ssl 2 & 3 */
  909.  
  910.     sslHandshakeFunc handshake;                /*firstHandshakeLock*/
  911.     sslHandshakeFunc nextHandshake;            /*firstHandshakeLock*/
  912.     sslHandshakeFunc securityHandshake;            /*firstHandshakeLock*/
  913.  
  914.     /* the following variable is only used with socks or other proxies. */
  915.     char *           peerID;    /* String uniquely identifies target server. */
  916.  
  917.     unsigned char *  cipherSpecs;
  918.     unsigned int     sizeCipherSpecs;
  919. const unsigned char *  preferredCipher;
  920.  
  921.     ssl3KeyPair *         stepDownKeyPair;    /* RSA step down keys */
  922.  
  923.     /* Callbacks */
  924.     SSLAuthCertificate        authCertificate;
  925.     void                     *authCertificateArg;
  926.     SSLGetClientAuthData      getClientAuthData;
  927.     void                     *getClientAuthDataArg;
  928.     SSLBadCertHandler         handleBadCert;
  929.     void                     *badCertArg;
  930.     SSLHandshakeCallback      handshakeCallback;
  931.     void                     *handshakeCallbackData;
  932.     void                     *pkcs11PinArg;
  933.  
  934.     PRIntervalTime            rTimeout; /* timeout for NSPR I/O */
  935.     PRIntervalTime            wTimeout; /* timeout for NSPR I/O */
  936.     PRIntervalTime            cTimeout; /* timeout for NSPR I/O */
  937.  
  938.     PZLock *      recvLock;    /* lock against multiple reader threads. */
  939.     PZLock *      sendLock;    /* lock against multiple sender threads. */
  940.  
  941.     PZMonitor *   recvBufLock;    /* locks low level recv buffers. */
  942.     PZMonitor *   xmitBufLock;    /* locks low level xmit buffers. */
  943.  
  944.     /* Only one thread may operate on the socket until the initial handshake
  945.     ** is complete.  This Monitor ensures that.  Since SSL2 handshake is
  946.     ** only done once, this is also effectively the SSL2 handshake lock.
  947.     */
  948.     PZMonitor *   firstHandshakeLock; 
  949.  
  950.     /* This monitor protects the ssl3 handshake state machine data.
  951.     ** Only one thread (reader or writer) may be in the ssl3 handshake state
  952.     ** machine at any time.  */
  953.     PZMonitor *   ssl3HandshakeLock;
  954.  
  955.     /* reader/writer lock, protects the secret data needed to encrypt and MAC
  956.     ** outgoing records, and to decrypt and MAC check incoming ciphertext 
  957.     ** records.  */
  958.     NSSRWLock *   specLock;
  959.  
  960.     /* handle to perm cert db (and implicitly to the temp cert db) used 
  961.     ** with this socket. 
  962.     */
  963.     CERTCertDBHandle * dbHandle;
  964.  
  965.     PRThread *  writerThread;   /* thread holds SSL_LOCK_WRITER lock */
  966.  
  967.     PRUint16    shutdownHow;     /* See ssl_SHUTDOWN defines below. */
  968.  
  969.     PRUint16    allowedByPolicy;          /* copy of global policy bits. */
  970.     PRUint16    maybeAllowedByPolicy;     /* copy of global policy bits. */
  971.     PRUint16    chosenPreference;         /* SSL2 cipher preferences. */
  972.  
  973.     sslHandshakingType handshaking;
  974.  
  975.     /* Gather object used for gathering data */
  976.     sslGather        gs;                /*recvBufLock*/
  977.  
  978.     sslBuffer        saveBuf;                /*xmitBufLock*/
  979.     sslBuffer        pendingBuf;            /*xmitBufLock*/
  980.  
  981.     /* Configuration state for server sockets */
  982.     /* server cert and key for each KEA type */
  983.     sslServerCerts        serverCerts[kt_kea_size];
  984.  
  985.     ssl3CipherSuiteCfg cipherSuites[ssl_V3_SUITES_IMPLEMENTED];
  986.     ssl3KeyPair *         ephemeralECDHKeyPair; /* for ECDHE-* handshake */
  987.  
  988.     /* SSL3 state info.  Formerly was a pointer */
  989.     ssl3State        ssl3;
  990. };
  991.  
  992.  
  993.  
  994. /* All the global data items declared here should be protected using the 
  995. ** ssl_global_data_lock, which is a reader/writer lock.
  996. */
  997. extern NSSRWLock *             ssl_global_data_lock;
  998. extern char                    ssl_debug;
  999. extern char                    ssl_trace;
  1000. extern CERTDistNames *         ssl3_server_ca_list;
  1001. extern PRUint32                ssl_sid_timeout;
  1002. extern PRUint32                ssl3_sid_timeout;
  1003. extern PRBool                  ssl3_global_policy_some_restricted;
  1004.  
  1005. extern const char * const      ssl_cipherName[];
  1006. extern const char * const      ssl3_cipherName[];
  1007.  
  1008. extern sslSessionIDLookupFunc  ssl_sid_lookup;
  1009. extern sslSessionIDCacheFunc   ssl_sid_cache;
  1010. extern sslSessionIDUncacheFunc ssl_sid_uncache;
  1011.  
  1012. /************************************************************************/
  1013.  
  1014. SEC_BEGIN_PROTOS
  1015.  
  1016. /* Implementation of ops for default (non socks, non secure) case */
  1017. extern int ssl_DefConnect(sslSocket *ss, const PRNetAddr *addr);
  1018. extern PRFileDesc *ssl_DefAccept(sslSocket *ss, PRNetAddr *addr);
  1019. extern int ssl_DefBind(sslSocket *ss, const PRNetAddr *addr);
  1020. extern int ssl_DefListen(sslSocket *ss, int backlog);
  1021. extern int ssl_DefShutdown(sslSocket *ss, int how);
  1022. extern int ssl_DefClose(sslSocket *ss);
  1023. extern int ssl_DefRecv(sslSocket *ss, unsigned char *buf, int len, int flags);
  1024. extern int ssl_DefSend(sslSocket *ss, const unsigned char *buf,
  1025.                int len, int flags);
  1026. extern int ssl_DefRead(sslSocket *ss, unsigned char *buf, int len);
  1027. extern int ssl_DefWrite(sslSocket *ss, const unsigned char *buf, int len);
  1028. extern int ssl_DefGetpeername(sslSocket *ss, PRNetAddr *name);
  1029. extern int ssl_DefGetsockname(sslSocket *ss, PRNetAddr *name);
  1030. extern int ssl_DefGetsockopt(sslSocket *ss, PRSockOption optname,
  1031.                  void *optval, PRInt32 *optlen);
  1032. extern int ssl_DefSetsockopt(sslSocket *ss, PRSockOption optname,
  1033.                  const void *optval, PRInt32 optlen);
  1034.  
  1035. /* Implementation of ops for socks only case */
  1036. extern int ssl_SocksConnect(sslSocket *ss, const PRNetAddr *addr);
  1037. extern PRFileDesc *ssl_SocksAccept(sslSocket *ss, PRNetAddr *addr);
  1038. extern int ssl_SocksBind(sslSocket *ss, const PRNetAddr *addr);
  1039. extern int ssl_SocksListen(sslSocket *ss, int backlog);
  1040. extern int ssl_SocksGetsockname(sslSocket *ss, PRNetAddr *name);
  1041. extern int ssl_SocksRecv(sslSocket *ss, unsigned char *buf, int len, int flags);
  1042. extern int ssl_SocksSend(sslSocket *ss, const unsigned char *buf,
  1043.              int len, int flags);
  1044. extern int ssl_SocksRead(sslSocket *ss, unsigned char *buf, int len);
  1045. extern int ssl_SocksWrite(sslSocket *ss, const unsigned char *buf, int len);
  1046.  
  1047. /* Implementation of ops for secure only case */
  1048. extern int ssl_SecureConnect(sslSocket *ss, const PRNetAddr *addr);
  1049. extern PRFileDesc *ssl_SecureAccept(sslSocket *ss, PRNetAddr *addr);
  1050. extern int ssl_SecureRecv(sslSocket *ss, unsigned char *buf,
  1051.               int len, int flags);
  1052. extern int ssl_SecureSend(sslSocket *ss, const unsigned char *buf,
  1053.               int len, int flags);
  1054. extern int ssl_SecureRead(sslSocket *ss, unsigned char *buf, int len);
  1055. extern int ssl_SecureWrite(sslSocket *ss, const unsigned char *buf, int len);
  1056. extern int ssl_SecureShutdown(sslSocket *ss, int how);
  1057. extern int ssl_SecureClose(sslSocket *ss);
  1058.  
  1059. /* Implementation of ops for secure socks case */
  1060. extern int ssl_SecureSocksConnect(sslSocket *ss, const PRNetAddr *addr);
  1061. extern PRFileDesc *ssl_SecureSocksAccept(sslSocket *ss, PRNetAddr *addr);
  1062. extern PRFileDesc *ssl_FindTop(sslSocket *ss);
  1063.  
  1064. /* Gather funcs. */
  1065. extern sslGather * ssl_NewGather(void);
  1066. extern SECStatus   ssl_InitGather(sslGather *gs);
  1067. extern void        ssl_DestroyGather(sslGather *gs);
  1068. extern int         ssl2_GatherData(sslSocket *ss, sslGather *gs, int flags);
  1069. extern int         ssl2_GatherRecord(sslSocket *ss, int flags);
  1070. extern SECStatus   ssl_GatherRecord1stHandshake(sslSocket *ss);
  1071.  
  1072. extern SECStatus   ssl2_HandleClientHelloMessage(sslSocket *ss);
  1073. extern SECStatus   ssl2_HandleServerHelloMessage(sslSocket *ss);
  1074. extern int         ssl2_StartGatherBytes(sslSocket *ss, sslGather *gs, 
  1075.                                          unsigned int count);
  1076.  
  1077. extern SECStatus   ssl_CreateSecurityInfo(sslSocket *ss);
  1078. extern SECStatus   ssl_CopySecurityInfo(sslSocket *ss, sslSocket *os);
  1079. extern void        ssl_ResetSecurityInfo(sslSecurityInfo *sec, PRBool doMemset);
  1080. extern void        ssl_DestroySecurityInfo(sslSecurityInfo *sec);
  1081.  
  1082. extern sslSocket * ssl_DupSocket(sslSocket *old);
  1083.  
  1084. extern void        ssl_PrintBuf(sslSocket *ss, const char *msg, const void *cp, int len);
  1085. extern void        ssl_DumpMsg(sslSocket *ss, unsigned char *bp, unsigned len);
  1086.  
  1087. extern int         ssl_SendSavedWriteData(sslSocket *ss, sslBuffer *buf,
  1088.                           sslSendFunc fp);
  1089. extern SECStatus ssl_SaveWriteData(sslSocket *ss, sslBuffer *buf, 
  1090.                                    const void* p, unsigned int l);
  1091. extern SECStatus ssl2_BeginClientHandshake(sslSocket *ss);
  1092. extern SECStatus ssl2_BeginServerHandshake(sslSocket *ss);
  1093. extern int       ssl_Do1stHandshake(sslSocket *ss);
  1094.  
  1095. extern SECStatus sslBuffer_Grow(sslBuffer *b, unsigned int newLen);
  1096.  
  1097. extern void      ssl2_UseClearSendFunc(sslSocket *ss);
  1098. extern void      ssl_ChooseSessionIDProcs(sslSecurityInfo *sec);
  1099.  
  1100. extern sslSessionID *ssl_LookupSID(const PRIPv6Addr *addr, PRUint16 port, 
  1101.                                    const char *peerID, const char *urlSvrName);
  1102. extern void      ssl_FreeSID(sslSessionID *sid);
  1103.  
  1104. extern int       ssl3_SendApplicationData(sslSocket *ss, const PRUint8 *in,
  1105.                           int len, int flags);
  1106.  
  1107. extern PRBool    ssl_FdIsBlocking(PRFileDesc *fd);
  1108.  
  1109. extern SECStatus ssl_SetTimeout(PRFileDesc *fd, PRIntervalTime timeout);
  1110.  
  1111. extern PRBool    ssl_SocketIsBlocking(sslSocket *ss);
  1112.  
  1113. extern void      ssl_SetAlwaysBlock(sslSocket *ss);
  1114.  
  1115. extern SECStatus ssl_EnableNagleDelay(sslSocket *ss, PRBool enabled);
  1116.  
  1117. #define SSL_LOCK_READER(ss)        if (ss->recvLock) PZ_Lock(ss->recvLock)
  1118. #define SSL_UNLOCK_READER(ss)        if (ss->recvLock) PZ_Unlock(ss->recvLock)
  1119. #define SSL_LOCK_WRITER(ss)        if (ss->sendLock) PZ_Lock(ss->sendLock)
  1120. #define SSL_UNLOCK_WRITER(ss)        if (ss->sendLock) PZ_Unlock(ss->sendLock)
  1121.  
  1122. #define ssl_Get1stHandshakeLock(ss)     \
  1123.     { if (!ss->opt.noLocks) PZ_EnterMonitor((ss)->firstHandshakeLock); }
  1124. #define ssl_Release1stHandshakeLock(ss) \
  1125.     { if (!ss->opt.noLocks) PZ_ExitMonitor((ss)->firstHandshakeLock); }
  1126. #define ssl_Have1stHandshakeLock(ss)    \
  1127.     (PZ_InMonitor((ss)->firstHandshakeLock))
  1128.  
  1129. #define ssl_GetSSL3HandshakeLock(ss)    \
  1130.     { if (!ss->opt.noLocks) PZ_EnterMonitor((ss)->ssl3HandshakeLock); }
  1131. #define ssl_ReleaseSSL3HandshakeLock(ss) \
  1132.     { if (!ss->opt.noLocks) PZ_ExitMonitor((ss)->ssl3HandshakeLock); }
  1133. #define ssl_HaveSSL3HandshakeLock(ss)    \
  1134.     (PZ_InMonitor((ss)->ssl3HandshakeLock))
  1135.  
  1136. #define ssl_GetSpecReadLock(ss)        \
  1137.     { if (!ss->opt.noLocks) NSSRWLock_LockRead((ss)->specLock); }
  1138. #define ssl_ReleaseSpecReadLock(ss)    \
  1139.     { if (!ss->opt.noLocks) NSSRWLock_UnlockRead((ss)->specLock); }
  1140.  
  1141. #define ssl_GetSpecWriteLock(ss)    \
  1142.     { if (!ss->opt.noLocks) NSSRWLock_LockWrite((ss)->specLock); }
  1143. #define ssl_ReleaseSpecWriteLock(ss)    \
  1144.     { if (!ss->opt.noLocks) NSSRWLock_UnlockWrite((ss)->specLock); }
  1145. #define ssl_HaveSpecWriteLock(ss)    \
  1146.     (NSSRWLock_HaveWriteLock((ss)->specLock))
  1147.  
  1148. #define ssl_GetRecvBufLock(ss)        \
  1149.     { if (!ss->opt.noLocks) PZ_EnterMonitor((ss)->recvBufLock); }
  1150. #define ssl_ReleaseRecvBufLock(ss)    \
  1151.     { if (!ss->opt.noLocks) PZ_ExitMonitor( (ss)->recvBufLock); }
  1152. #define ssl_HaveRecvBufLock(ss)        \
  1153.     (PZ_InMonitor((ss)->recvBufLock))
  1154.  
  1155. #define ssl_GetXmitBufLock(ss)        \
  1156.     { if (!ss->opt.noLocks) PZ_EnterMonitor((ss)->xmitBufLock); }
  1157. #define ssl_ReleaseXmitBufLock(ss)    \
  1158.     { if (!ss->opt.noLocks) PZ_ExitMonitor( (ss)->xmitBufLock); }
  1159. #define ssl_HaveXmitBufLock(ss)        \
  1160.     (PZ_InMonitor((ss)->xmitBufLock))
  1161.  
  1162.  
  1163. extern SECStatus ssl3_KeyAndMacDeriveBypass(ssl3CipherSpec * pwSpec,
  1164.             const unsigned char * cr, const unsigned char * sr,
  1165.             PRBool isTLS, PRBool isExport);
  1166. extern  SECStatus ssl3_MasterKeyDeriveBypass( ssl3CipherSpec * pwSpec,
  1167.             const unsigned char * cr, const unsigned char * sr,
  1168.             const SECItem * pms, PRBool isTLS, PRBool isRSA);
  1169.  
  1170. /* These functions are called from secnav, even though they're "private". */
  1171.  
  1172. extern int ssl2_SendErrorMessage(struct sslSocketStr *ss, int error);
  1173. extern int SSL_RestartHandshakeAfterServerCert(struct sslSocketStr *ss);
  1174. extern int SSL_RestartHandshakeAfterCertReq(struct sslSocketStr *ss,
  1175.                         CERTCertificate *cert,
  1176.                         SECKEYPrivateKey *key,
  1177.                         CERTCertificateList *certChain);
  1178. extern sslSocket *ssl_FindSocket(PRFileDesc *fd);
  1179. extern void ssl_FreeSocket(struct sslSocketStr *ssl);
  1180. extern SECStatus SSL3_SendAlert(sslSocket *ss, SSL3AlertLevel level,
  1181.                 SSL3AlertDescription desc);
  1182.  
  1183. extern int ssl2_RestartHandshakeAfterCertReq(sslSocket *          ss,
  1184.                          CERTCertificate *    cert, 
  1185.                          SECKEYPrivateKey *   key);
  1186.  
  1187. extern SECStatus ssl3_RestartHandshakeAfterCertReq(sslSocket *    ss,
  1188.                          CERTCertificate *    cert, 
  1189.                          SECKEYPrivateKey *   key,
  1190.                          CERTCertificateList *certChain);
  1191.  
  1192. extern int ssl2_RestartHandshakeAfterServerCert(sslSocket *ss);
  1193. extern int ssl3_RestartHandshakeAfterServerCert(sslSocket *ss);
  1194.  
  1195. /*
  1196.  * for dealing with SSL 3.0 clients sending SSL 2.0 format hellos
  1197.  */
  1198. extern SECStatus ssl3_HandleV2ClientHello(
  1199.     sslSocket *ss, unsigned char *buffer, int length);
  1200. extern SECStatus ssl3_StartHandshakeHash(
  1201.     sslSocket *ss, unsigned char *buf, int length);
  1202.  
  1203. /*
  1204.  * SSL3 specific routines
  1205.  */
  1206. SECStatus ssl3_SendClientHello(sslSocket *ss);
  1207.  
  1208. /*
  1209.  * input into the SSL3 machinery from the actualy network reading code
  1210.  */
  1211. SECStatus ssl3_HandleRecord(
  1212.     sslSocket *ss, SSL3Ciphertext *cipher, sslBuffer *out);
  1213.  
  1214. int ssl3_GatherAppDataRecord(sslSocket *ss, int flags);
  1215. int ssl3_GatherCompleteHandshake(sslSocket *ss, int flags);
  1216. /*
  1217.  * When talking to export clients or using export cipher suites, servers 
  1218.  * with public RSA keys larger than 512 bits need to use a 512-bit public
  1219.  * key, signed by the larger key.  The smaller key is a "step down" key.
  1220.  * Generate that key pair and keep it around.
  1221.  */
  1222. extern SECStatus ssl3_CreateRSAStepDownKeys(sslSocket *ss);
  1223.  
  1224. #ifdef NSS_ENABLE_ECC
  1225. extern SECStatus ssl3_CreateECDHEphemeralKeys(sslSocket *ss);
  1226. #endif /* NSS_ENABLE_ECC */
  1227.  
  1228. extern SECStatus ssl3_CipherPrefSetDefault(ssl3CipherSuite which, PRBool on);
  1229. extern SECStatus ssl3_CipherPrefGetDefault(ssl3CipherSuite which, PRBool *on);
  1230. extern SECStatus ssl2_CipherPrefSetDefault(PRInt32 which, PRBool enabled);
  1231. extern SECStatus ssl2_CipherPrefGetDefault(PRInt32 which, PRBool *enabled);
  1232.  
  1233. extern SECStatus ssl3_CipherPrefSet(sslSocket *ss, ssl3CipherSuite which, PRBool on);
  1234. extern SECStatus ssl3_CipherPrefGet(sslSocket *ss, ssl3CipherSuite which, PRBool *on);
  1235. extern SECStatus ssl2_CipherPrefSet(sslSocket *ss, PRInt32 which, PRBool enabled);
  1236. extern SECStatus ssl2_CipherPrefGet(sslSocket *ss, PRInt32 which, PRBool *enabled);
  1237.  
  1238. extern SECStatus ssl3_SetPolicy(ssl3CipherSuite which, PRInt32 policy);
  1239. extern SECStatus ssl3_GetPolicy(ssl3CipherSuite which, PRInt32 *policy);
  1240. extern SECStatus ssl2_SetPolicy(PRInt32 which, PRInt32 policy);
  1241. extern SECStatus ssl2_GetPolicy(PRInt32 which, PRInt32 *policy);
  1242.  
  1243. extern void      ssl2_InitSocketPolicy(sslSocket *ss);
  1244. extern void      ssl3_InitSocketPolicy(sslSocket *ss);
  1245.  
  1246. extern SECStatus ssl3_ConstructV2CipherSpecsHack(sslSocket *ss,
  1247.                          unsigned char *cs, int *size);
  1248.  
  1249. extern SECStatus ssl3_RedoHandshake(sslSocket *ss, PRBool flushCache);
  1250.  
  1251. extern void ssl3_DestroySSL3Info(sslSocket *ss);
  1252.  
  1253. extern SECStatus ssl3_NegotiateVersion(sslSocket *ss, 
  1254.                                        SSL3ProtocolVersion peerVersion);
  1255.  
  1256. extern SECStatus ssl_GetPeerInfo(sslSocket *ss);
  1257.  
  1258. #ifdef NSS_ENABLE_ECC
  1259. /* ECDH functions */
  1260. extern SECStatus ssl3_SendECDHClientKeyExchange(sslSocket * ss, 
  1261.                  SECKEYPublicKey * svrPubKey);
  1262. extern SECStatus ssl3_HandleECDHServerKeyExchange(sslSocket *ss, 
  1263.                     SSL3Opaque *b, PRUint32 length);
  1264. extern SECStatus ssl3_HandleECDHClientKeyExchange(sslSocket *ss, 
  1265.                      SSL3Opaque *b, PRUint32 length,
  1266.                                      SECKEYPublicKey *srvrPubKey,
  1267.                                      SECKEYPrivateKey *srvrPrivKey);
  1268. extern SECStatus ssl3_SendECDHServerKeyExchange(sslSocket *ss);
  1269. #endif
  1270.  
  1271. extern SECStatus ssl3_ComputeCommonKeyHash(PRUint8 * hashBuf, 
  1272.                 unsigned int bufLen, SSL3Hashes *hashes, 
  1273.                 PRBool bypassPKCS11);
  1274. extern SECStatus ssl3_InitPendingCipherSpec(sslSocket *ss, PK11SymKey *pms);
  1275. extern SECStatus ssl3_AppendHandshake(sslSocket *ss, const void *void_src, 
  1276.             PRInt32 bytes);
  1277. extern SECStatus ssl3_AppendHandshakeHeader(sslSocket *ss, 
  1278.             SSL3HandshakeType t, PRUint32 length);
  1279. extern SECStatus ssl3_AppendHandshakeVariable( sslSocket *ss, 
  1280.             const SSL3Opaque *src, PRInt32 bytes, PRInt32 lenSize);
  1281. extern SECStatus ssl3_ConsumeHandshake(sslSocket *ss, void *v, PRInt32 bytes, 
  1282.             SSL3Opaque **b, PRUint32 *length);
  1283. extern SECStatus ssl3_ConsumeHandshakeVariable(sslSocket *ss, SECItem *i, 
  1284.             PRInt32 bytes, SSL3Opaque **b, PRUint32 *length);
  1285. extern SECStatus ssl3_SignHashes(SSL3Hashes *hash, SECKEYPrivateKey *key, 
  1286.             SECItem *buf, PRBool isTLS);
  1287. extern SECStatus ssl3_VerifySignedHashes(SSL3Hashes *hash, 
  1288.             CERTCertificate *cert, SECItem *buf, PRBool isTLS, 
  1289.             void *pwArg);
  1290.  
  1291. /* Construct a new NSPR socket for the app to use */
  1292. extern PRFileDesc *ssl_NewPRSocket(sslSocket *ss, PRFileDesc *fd);
  1293. extern void ssl_FreePRSocket(PRFileDesc *fd);
  1294.  
  1295. /* Internal config function so SSL2 can initialize the present state of 
  1296.  * various ciphers */
  1297. extern int ssl3_config_match_init(sslSocket *);
  1298.  
  1299.  
  1300. /* Create a new ref counted key pair object from two keys. */
  1301. extern ssl3KeyPair * ssl3_NewKeyPair( SECKEYPrivateKey * privKey, 
  1302.                                       SECKEYPublicKey * pubKey);
  1303.  
  1304. /* get a new reference (bump ref count) to an ssl3KeyPair. */
  1305. extern ssl3KeyPair * ssl3_GetKeyPairRef(ssl3KeyPair * keyPair);
  1306.  
  1307. /* Decrement keypair's ref count and free if zero. */
  1308. extern void ssl3_FreeKeyPair(ssl3KeyPair * keyPair);
  1309.  
  1310. /* calls for accessing wrapping keys across processes. */
  1311. extern PRBool
  1312. ssl_GetWrappingKey( PRInt32                   symWrapMechIndex,
  1313.                     SSL3KEAType               exchKeyType, 
  1314.             SSLWrappedSymWrappingKey *wswk);
  1315.  
  1316. /* The caller passes in the new value it wants
  1317.  * to set.  This code tests the wrapped sym key entry in the file on disk.  
  1318.  * If it is uninitialized, this function writes the caller's value into 
  1319.  * the disk entry, and returns false.  
  1320.  * Otherwise, it overwrites the caller's wswk with the value obtained from 
  1321.  * the disk, and returns PR_TRUE.  
  1322.  * This is all done while holding the locks/semaphores necessary to make 
  1323.  * the operation atomic.
  1324.  */
  1325. extern PRBool
  1326. ssl_SetWrappingKey(SSLWrappedSymWrappingKey *wswk);
  1327.  
  1328. /* get rid of the symmetric wrapping key references. */
  1329. extern SECStatus SSL3_ShutdownServerCache(void);
  1330.  
  1331. extern void ssl_InitClientSessionCacheLock(void);
  1332.  
  1333. extern void ssl_InitSymWrapKeysLock(void);
  1334.  
  1335. /********************** misc calls *********************/
  1336.  
  1337. extern int ssl_MapLowLevelError(int hiLevelError);
  1338.  
  1339. extern PRUint32 ssl_Time(void);
  1340.  
  1341. /* emulation of NSPR routines. */
  1342. extern PRInt32 
  1343. ssl_EmulateAcceptRead(    PRFileDesc *   sd, 
  1344.             PRFileDesc **  nd,
  1345.             PRNetAddr **   raddr, 
  1346.             void *         buf, 
  1347.             PRInt32        amount, 
  1348.             PRIntervalTime timeout);
  1349. extern PRInt32 
  1350. ssl_EmulateTransmitFile(    PRFileDesc *        sd, 
  1351.                 PRFileDesc *        fd,
  1352.                 const void *        headers, 
  1353.                 PRInt32             hlen, 
  1354.                 PRTransmitFileFlags flags,
  1355.                 PRIntervalTime      timeout);
  1356. extern PRInt32 
  1357. ssl_EmulateSendFile( PRFileDesc *        sd, 
  1358.              PRSendFileData *    sfd,
  1359.                      PRTransmitFileFlags flags, 
  1360.              PRIntervalTime      timeout);
  1361.  
  1362.  
  1363. SECStatus SSL_DisableDefaultExportCipherSuites(void);
  1364. SECStatus SSL_DisableExportCipherSuites(PRFileDesc * fd);
  1365. PRBool    SSL_IsExportCipherSuite(PRUint16 cipherSuite);
  1366.  
  1367.  
  1368. #ifdef TRACE
  1369. #define SSL_TRACE(msg) ssl_Trace msg
  1370. #else
  1371. #define SSL_TRACE(msg)
  1372. #endif
  1373.  
  1374. void ssl_Trace(const char *format, ...);
  1375.  
  1376. SEC_END_PROTOS
  1377.  
  1378. #ifdef XP_OS2_VACPP
  1379. #include <process.h>
  1380. #endif
  1381.  
  1382. #if defined(XP_UNIX) || defined(XP_OS2) || defined(XP_BEOS)
  1383. #define SSL_GETPID getpid
  1384. #elif defined(_WIN32_WCE)
  1385. #define SSL_GETPID GetCurrentProcessId
  1386. #elif defined(WIN32)
  1387. extern int __cdecl _getpid(void);
  1388. #define SSL_GETPID _getpid
  1389. #else
  1390. #define SSL_GETPID() 0
  1391. #endif
  1392.  
  1393. #endif /* __sslimpl_h_ */
  1394.